home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 12 / BBS in a box XII-1.iso / Files / Unstuffers / Other Compression / MacGzip 0.21-src-c.sit / macgzip_021-src / macos / think / thePrefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-25  |  12.9 KB  |  473 lines  |  [TEXT/KAHL]
  1. /*            SpinCursors by
  2.  *            America Online: LISPer
  3.  *             Internet: tree@uvm.edu
  4. */
  5. #ifndef _FOLDERS_
  6. #include <Folders.h>
  7. #endif
  8. #include <Script.h>
  9.  
  10. #include "thePrefs.h"
  11. #include "MacErrors.h"
  12.  
  13.  
  14. /************************************************************************************/
  15.  
  16. #define kPrefsDialogID        130
  17. #define kSaveButtonItem        1
  18. #define kCancelButtonItem    2
  19.  
  20. #define kBeepWD                14
  21. #define kQuitWD                5
  22.  
  23. #define kForce                7
  24.  
  25. #define kTEXTsuffix            3
  26. #define kTEXTcreator        4
  27. #define kTEXTlevel            10
  28.  
  29. #define kUpArrow            11
  30. #define kDownArrow            12
  31.  
  32. /* prefs file constants */
  33. #define kPrefsNameStrID        128
  34. #define kPrefsCreatorType    '\?\?\?\?'
  35. #define kPrefsFileType        'pref'
  36. #define kPrefsResourceType    'Pref'
  37. #define kPrefsResourceID    128
  38.  
  39. #define kFinderMessageStrID    -16397 /* ID of STR for default finder message */
  40.                                    /* see Inside Mac VI, page 9-22         */
  41. #define kStrType            'STR '
  42.  
  43. #define CmdKeyMask            0x0100
  44.  
  45. /*
  46.  * From DialogBits,C.K. Haun
  47.  * Apple Developer Tech Support
  48.  */
  49.  
  50.  /* key equates */
  51. enum  {
  52.     kEnterKey        = 0x03, 
  53.     kTabKey            = 9, 
  54.     kReturnKey        = 0x0D, 
  55.     kBackSpace        = 8, 
  56.     kEscKey            = 0x1B, 
  57.     kLeftArrowKey    = 0x1C, 
  58.     kRightArrowKey, 
  59.     kUpArrowKey,
  60.     kDownArrowKey, 
  61.     kDeleteKey        = 0x7F
  62. };
  63.  
  64. pascal Boolean filterIt(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem);
  65.  
  66. pascal OSErr GetStdFilterProc(ModalFilterProcPtr *theProc) = 
  67. {
  68.     0x303C, 0x0203, 0xAA68
  69. };
  70.  
  71. /* Indicates to the dialog manager which item is default.  Will then alias the return key */
  72. /* to this item, and also bold border it for you (yaaaaa!) */
  73. pascal OSErr SetDialogDefaultItem(DialogPtr theDialog, short newItem)
  74. = 
  75. {
  76.     0x303C, 0x0304, 0xAA68
  77. };
  78.  
  79. /* Indicates which item should be aliased to escape or Command - . */
  80. pascal OSErr SetDialogCancelItem(DialogPtr theDialog, short newItem)
  81. = 
  82. {
  83.     0x303C, 0x0305, 0xAA68
  84. };
  85. /* End From DialogBits */
  86.  
  87. /* these constants may be stored in the fields of the prefs struct */
  88.  
  89. OSErr GetPrefsName (StringPtr prefName);
  90.  
  91. PrefsType currPrefs;
  92. Boolean prefsChangedFlag;
  93.  
  94. short OpenPrefsResFile(SignedByte prefsPerm, Boolean createFlag)
  95. /* open the preferences file with the given permission; if createFlag is set,
  96.    create a preferences file if necessary */
  97. {
  98.     OSErr retCode;
  99.     short prefsVRefNum;
  100.     long prefsDirID;
  101.     Str255 prefsNameStr;
  102.     FSSpec prefsFSSpec;
  103.     short prefsResRefNum = -1;
  104.     
  105.     /* get the name of the prefs file */
  106.     retCode = GetPrefsName(prefsNameStr);
  107.     if (retCode == noErr) {
  108.     
  109.         /* Use FindFolder to locate the Preferences folder.
  110.         
  111.            MPW 3.2 and some other compilers provide the
  112.            glue necessary to use FindFolder (and Gestalt) safely
  113.            under System 6 and earlier.  Under System 6, the dirID
  114.            returned for the Preferences folder request will be
  115.            the System folder's dirID */
  116.  
  117.         retCode = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  118.             &prefsVRefNum, &prefsDirID);
  119.         if (retCode == noErr) {
  120.         
  121.             /* make a file spec for the prefs file */
  122.             
  123.             retCode = FSMakeFSSpec(prefsVRefNum, prefsDirID, prefsNameStr,
  124.                 &prefsFSSpec);
  125.                 
  126.             if (retCode == fnfErr && createFlag) {
  127.                 /* prefs file doesn't already exist, so create it */
  128.                 FSpCreateResFile(&prefsFSSpec, kPrefsCreatorType, kPrefsFileType,
  129.                     smSystemScript);
  130.                 retCode = ResError();
  131.             }
  132.             
  133.             /* open the prefs file */
  134.             if (retCode == noErr) {
  135.                 prefsResRefNum = FSpOpenResFile(&prefsFSSpec, prefsPerm);
  136.             }
  137.         }
  138.     }
  139.     return prefsResRefNum;
  140. }
  141.  
  142. OSErr GetPrefsName (StringPtr prefName)
  143. /* get the name of the preferences file from a resource in the application */
  144. {
  145.     StringHandle prefStrHandle;
  146.     OSErr retCode = noErr;
  147.     
  148.     prefStrHandle = GetString(kPrefsNameStrID);
  149.     if (prefStrHandle != nil) 
  150.         BlockMove(*prefStrHandle, prefName, (Size) (**prefStrHandle) + 1);
  151.     else retCode = resNotFound;
  152.     
  153.     return retCode;
  154. }
  155.  
  156. Boolean GetOrGeneratePrefs( PrefsType * thePrefsTypePtr, long wantedVers )
  157. /* fill in the prefs structure from the resource file or from scratch */
  158. {
  159.     short prefsResRefNum;
  160.     Handle tempHandle;
  161.     extern    Boolean        gSavedPos;
  162.     extern    Point        gSavedPoint;
  163.     Str255 defaultStr = "\pttxt";
  164.     
  165.     /* initialize prefs structure in case we can't get a valid set */
  166.     thePrefsTypePtr->prefsTypeVers = wantedVers;
  167.     thePrefsTypePtr->compress = false;
  168.     thePrefsTypePtr->ascii = false;
  169.     thePrefsTypePtr->level = 6;
  170.     thePrefsTypePtr->force = false;
  171.     thePrefsTypePtr->suffix[0]=0x00;
  172.     BlockMove(defaultStr, thePrefsTypePtr->textcreator, *defaultStr+1);
  173.     thePrefsTypePtr->QuitWhenDone = true;
  174.     thePrefsTypePtr->BeepWhenDone = false;
  175.     thePrefsTypePtr->SavedPos = false;
  176.     thePrefsTypePtr->SavedPoint.h = 0;
  177.     thePrefsTypePtr->SavedPoint.v = 0;
  178.     
  179.     
  180.     /* open (but don't create) the prefs file */
  181.     prefsResRefNum = OpenPrefsResFile(fsRdPerm, false);
  182.     if (prefsResRefNum != -1) {
  183.     
  184.         /* file opened successfully, get the prefs resource */
  185.         tempHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  186.         
  187.         /* if the resource is there and it's the right size and version, copy it */
  188.         /* (in C these can be combined with &&, but don't use AND in Pascal)     */
  189.         
  190.         if (tempHandle != nil)
  191.             if (GetHandleSize(tempHandle) == sizeof(PrefsType)) 
  192.                 if ((*(PrefsType *)*tempHandle).prefsTypeVers == wantedVers) {
  193.                 
  194.                     /* copy the prefs struct */
  195.                     *thePrefsTypePtr = *(PrefsType *)*tempHandle;
  196.                     
  197.                 }
  198.         /* release the pref resource and close the file */
  199.         CloseResFile(prefsResRefNum);
  200.  
  201.         gSavedPos = thePrefsTypePtr->SavedPos;
  202.         gSavedPoint.h = thePrefsTypePtr->SavedPoint.h;
  203.         gSavedPoint.v = thePrefsTypePtr->SavedPoint.v;
  204.  
  205.     return true;
  206.     
  207.     }
  208.     else
  209.         return false;
  210. }
  211. OSErr SavePrefs(PrefsType * thePrefsTypePtr )
  212. /* save the prefs structure in the prefs resource file */
  213. {
  214.     OSErr retCode;
  215.     short prefsResRefNum;
  216.     Handle prefHandle, finderMessageHandle;
  217.     
  218.     /* open (and, if necessary, create) the prefs file */
  219.     prefsResRefNum = OpenPrefsResFile(fsRdWrPerm, true);
  220.     if (prefsResRefNum != -1) {
  221.     
  222.         /* file opened successfully, get the prefs resource */
  223.         prefHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  224.         
  225.         if (prefHandle == nil) {
  226.         
  227.             /* create a new resource */
  228.             prefHandle = NewHandle(sizeof(PrefsType));
  229.             if (prefHandle != nil) {
  230.             
  231.                 /* copy the prefs struct into the handle
  232.                    and make it into a resource */
  233.                 
  234.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  235.                 AddResource(prefHandle, kPrefsResourceType, kPrefsResourceID, 
  236.                     "\pPrefsType");
  237.                 retCode = ResError();
  238.                 if (retCode != noErr) DisposHandle(prefHandle);
  239.             } 
  240.             
  241.             else retCode = MemError(); /* NewHandle failed */
  242.         }
  243.         
  244.         else {  /* prefHandle != nil */
  245.         
  246.             /* update the existing resource */
  247.             SetHandleSize(prefHandle, sizeof(PrefsType));
  248.             retCode = MemError();
  249.             if (retCode == noErr) {
  250.  
  251.                 /* copy the prefs struct into the handle and tell the rsrc manager */
  252.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  253.                 ChangedResource(prefHandle);
  254.             }
  255.         }
  256.         if (retCode == noErr) {
  257.         
  258.             /* add the message to be displayed if the user tries
  259.                to open the prefs file in the Finder (but don't add it
  260.                if it's already in the preferences file) */
  261.                
  262.             finderMessageHandle = (Handle) GetString(kFinderMessageStrID);
  263.             if (finderMessageHandle != nil &&
  264.                 HomeResFile((Handle) finderMessageHandle) != prefsResRefNum) {
  265.             
  266.                 /* copy the resource into the prefs file */
  267.                 DetachResource(finderMessageHandle);
  268.                 AddResource(finderMessageHandle, kStrType, kFinderMessageStrID,
  269.                     "\pFinder message");
  270.                     
  271.                 /* if AddResource failed, dispose of the handle */
  272.                 retCode = ResError();
  273.                 if (retCode != noErr) DisposHandle(finderMessageHandle);
  274.             }
  275.         }
  276.         
  277.         /* update and close the preference resource file, 
  278.            releasing its resources from memory */
  279.         CloseResFile(prefsResRefNum);
  280.     }
  281.     
  282.     else {
  283.         /* couldn't open the res file */
  284.         retCode = ResError();
  285.         if (retCode == noErr) retCode = resFNotFound;
  286.     }
  287.     
  288.     return retCode;
  289. }
  290. /***********************Dialog*************/
  291. Boolean DoPrefsDialog(PrefsType * thePrefsTypePtr)
  292. /* display the prefs dialog; returns true if change made to prefs record */
  293. {
  294.     GrafPtr savePort;
  295.     DialogPtr prefDialogPtr;
  296.     short item;
  297.     Boolean doneFlag = false;
  298.     OSErr retCode;
  299.  
  300.     /* keep the new preference settings only in local variables
  301.        in case the user cancels */
  302.        
  303.     PrefsType newPrefsType;
  304.  
  305.     short        itemType;
  306.     Handle        itemHandle;
  307.     Rect        itemRect;
  308.     Str255        sTemp;
  309.     
  310.     Boolean changedFlag;
  311.  
  312.  
  313.     /* the old settings are our starting point, so copy them */
  314.     newPrefsType = *thePrefsTypePtr;
  315.     
  316.     /* throw up the dialog */
  317.     prefDialogPtr = GetNewDialog(kPrefsDialogID, nil, (WindowPtr) -1);
  318.     if (prefDialogPtr == nil) ExitToShell();  /* hurtin’ bad */
  319.     
  320.     SetDialogDefaultItem( prefDialogPtr, kSaveButtonItem);
  321.     SetDialogCancelItem( prefDialogPtr, kCancelButtonItem);
  322.  
  323.     /* set up the dialog to the initial values */
  324.  
  325.     GetDItem(prefDialogPtr, kForce, &itemType, &itemHandle, &itemRect);
  326.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.force ? 1 : 0));
  327.  
  328.     GetDItem(prefDialogPtr, kBeepWD, &itemType, &itemHandle, &itemRect);
  329.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.BeepWhenDone ? 1 : 0));
  330.  
  331.     GetDItem(prefDialogPtr, kQuitWD, &itemType, &itemHandle, &itemRect);
  332.     SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.QuitWhenDone ? 1 : 0));
  333. /*    HiliteControl ((ControlHandle) itemHandle, 255 );*/
  334.  
  335.     GetDItem(prefDialogPtr, kTEXTsuffix, &itemType, &itemHandle, &itemRect);
  336.     SetIText(itemHandle,thePrefsTypePtr->suffix);
  337.  
  338.     GetDItem(prefDialogPtr, kTEXTcreator, &itemType, &itemHandle, &itemRect);
  339.     SetIText(itemHandle,thePrefsTypePtr->textcreator);
  340.     SelIText(prefDialogPtr, kTEXTsuffix, 0, 32767);
  341.     
  342.     GetDItem(prefDialogPtr,kTEXTlevel, &itemType, &itemHandle, &itemRect);
  343.     NumToString( (long)thePrefsTypePtr->level, sTemp );
  344.     SetIText(itemHandle,sTemp);
  345.  
  346.     do {
  347.         GetPort(&savePort);
  348.         SetPort(prefDialogPtr);
  349.         ModalDialog((ModalFilterProcPtr)filterIt, &item);
  350.         switch(item) {
  351.         
  352.             case kSaveButtonItem:
  353.                 /* user wants to save the current or new settings */
  354.                 
  355.                 /* copy the editText string into the new prefs record */
  356.                 GetDItem(prefDialogPtr, kTEXTcreator, 
  357.                     &itemType, &itemHandle, &itemRect);
  358.                 GetIText(itemHandle, newPrefsType.textcreator);
  359.                 
  360.                 GetDItem(prefDialogPtr, kTEXTsuffix, 
  361.                     &itemType, &itemHandle, &itemRect);
  362.                 GetIText(itemHandle, newPrefsType.suffix);
  363.                 
  364.                 if(newPrefsType.textcreator[0]!=0x04)
  365.                 {
  366.                     Calert( "TEXT creator not valid" );
  367.                 }
  368.                 else
  369.                 {
  370.                         /* replace the old record with the new record */
  371.                         *thePrefsTypePtr = newPrefsType;
  372.                         doneFlag = true;
  373.                 }
  374.                 break;
  375.                 
  376.             case kCancelButtonItem:
  377.                 /* abandon the new preferences structure */
  378.                 doneFlag = true;
  379.                 break;
  380.                 
  381.             case kForce:
  382.             
  383.                 newPrefsType.force = !newPrefsType.force;
  384.                 GetDItem(prefDialogPtr, kForce, &itemType, &itemHandle, &itemRect);
  385.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.force ? 1 : 0));
  386.                 break;
  387.                 
  388.             case kBeepWD:
  389.             
  390.                 newPrefsType.BeepWhenDone = !newPrefsType.BeepWhenDone;
  391.                 GetDItem(prefDialogPtr, kBeepWD, &itemType, &itemHandle, &itemRect);
  392.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.BeepWhenDone ? 1 : 0));
  393.                 break;
  394.                 
  395.             case kQuitWD:
  396.             
  397.                 newPrefsType.QuitWhenDone = !newPrefsType.QuitWhenDone;
  398.                 GetDItem(prefDialogPtr, kQuitWD, &itemType, &itemHandle, &itemRect);
  399.                 SetCtlValue((ControlHandle) itemHandle, ( newPrefsType.QuitWhenDone ? 1 : 0));
  400.                 break;
  401.                 
  402.             case kUpArrow:
  403.             
  404.                 if ( newPrefsType.level < 9 )
  405.                 {
  406.                     newPrefsType.level++;
  407.                     GetDItem(prefDialogPtr,kUpArrow, &itemType, &itemHandle, &itemRect);
  408.                     InvertRect(&itemRect);
  409.                     while (StillDown())
  410.                     ;
  411.                     InvertRect(&itemRect);
  412.                     GetDItem(prefDialogPtr,kTEXTlevel, &itemType, &itemHandle, &itemRect);
  413.                     NumToString( (long)newPrefsType.level, sTemp );
  414.                     SetIText(itemHandle,sTemp);
  415.                 }
  416.                 break;
  417.                 
  418.             case kDownArrow:
  419.             
  420.                 if ( newPrefsType.level > 1 )
  421.                 {
  422.                     newPrefsType.level--;
  423.                     GetDItem(prefDialogPtr,kDownArrow, &itemType, &itemHandle, &itemRect);
  424.                     InvertRect(&itemRect);
  425.                     while (StillDown())
  426.                     ;
  427.                     InvertRect(&itemRect);
  428.                     GetDItem(prefDialogPtr,kTEXTlevel, &itemType, &itemHandle, &itemRect);
  429.                     NumToString( (long)newPrefsType.level, sTemp );
  430.                     SetIText(itemHandle,sTemp);
  431.                 }
  432.                 break;
  433.                 
  434.         }
  435.     } while (!doneFlag);
  436.     
  437.     DisposDialog(prefDialogPtr);
  438.     
  439.     SetPort(savePort);
  440.  
  441.     /* if the user clicked Save, return true */
  442.     return (item == kSaveButtonItem);
  443. }
  444.  
  445. pascal Boolean filterIt(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem)
  446. {
  447.     ModalFilterProcPtr theModalProc;
  448.     Boolean returnVal = false;
  449.     char theKey;
  450.     
  451.     if (((myDialogEvent->what == keyDown) || (myDialogEvent->what == autoKey)) &&
  452.         (myDialogEvent->modifiers & CmdKeyMask))
  453.     {
  454.         theKey = myDialogEvent->message & charCodeMask;
  455.         switch (theKey)
  456.         {
  457.             case kUpArrowKey:
  458.                             *theDialogItem = kUpArrow;
  459.                             returnVal = true;
  460.                             break;
  461.             case kDownArrowKey:
  462.                             *theDialogItem = kDownArrow;
  463.                             returnVal = true;
  464.                             break;
  465.         }
  466.     }
  467.     
  468.     if (!returnVal)
  469.         if (GetStdFilterProc(&theModalProc) == noErr)
  470.             returnVal=theModalProc(inputDialog, myDialogEvent, theDialogItem);
  471.  
  472.     return(returnVal);
  473. }